/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.dataPlain.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-21
*
* 依赖项：
*   1、jquery.jdirk.js
*   2、jeasyui.extensions.tree.dataPlain.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var _originalMethod = {};
    $.extend(_originalMethod, {
        _loadFilter: $.fn.treegrid.defaults.loadFilter
    });


    function resetExtensionsEvent(t, opts) {
        var target = t[0],
            state = $.data(target, "treegrid");
        if (opts.dataPlain) {
            //重写 easyui-treegrid 的 loadFilter 属性，以支持平滑数据格式。
            var _loadFilter = opts.loadFilter;
            opts.loadFilter = function (data, parent) {
                if ($.isFunction(_originalMethod._loadFilter)) { data = _originalMethod._loadFilter.apply(this, arguments); }
                if ($.isFunction(_loadFilter)) { data = _loadFilter.apply(this, arguments); }

                var isArray = $.array.likeArray(data) && !$.util.isString(data), rows = isArray ? data : data.rows;
                if (!rows || !rows.length) { return data; }

                rows = opts.dataPlain ? $.fn.tree.extensions.dataPlainConverter(rows, opts) : rows;
                if (parent != null && parent != undefined) { return isArray ? rows : { total: rows.length, rows: rows }; }
                return isArray ? rows : { total: data.length || rows.length, rows: rows };
            };
        }
    }

    function initializeExtensions(target) {
        var t = $(target),
            state = $.data(target, "treegrid"),
            opts = state.options;

        resetExtensionsEvent(t, opts);
    }

    var _treegrid = $.fn.treegrid;
    $.fn.treegrid = function (options, param) {
        if (typeof options == "string") {
            return _treegrid.apply(this, arguments);
        }
        options = options || {};
        return this.each(function () {
            var jq = $(this),
                isInited = $.data(this, "treegrid") ? true : false,
                opts = isInited ? options : $.extend({},
                        $.fn.treegrid.parseOptions(this),
                        $.parser.parseOptions(this, [
                            "parentField",
                            { dataPlain: "boolean" }
                        ]), options);
            _treegrid.call(jq, opts, param);
            if (!isInited) {
                initializeExtensions(this);
            }
        });
    };
    $.union($.fn.treegrid, _treegrid);


    var defaults = {

        //  扩展 easyui-treegrid 的自定义属性，表示当前 easyui-treegrid 控件是否支持平滑数据格式。
        //  当支持平滑数据格式时，数据元素中不需要通过指定 children 来指定子节点，而是支持通过 pid 属性来指示其父级节点。
        //  Boolean 类型值，默认为 false。
        dataPlain: false,

        //  扩展 easyui-treegrid 的自定义属性，表示当前 easyui-treegrid 控件支持平滑数据格式时，用哪个 field 表示当前行数据的父级节点 idField 值
        //  String 类型值，默认为 "pid"。
        parentField: "pid"
    };

    var methods = {

    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.getRowInfo.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-11
*
* 依赖项：
*   1、jquery.jdirk.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");


    var getRows = function (target, cascade) {
        var t = $(target), rows = t.treegrid("getRoots"), opts = t.treegrid("options");
        rows = rows && rows.length ? rows : [];
        return cascade ? $.array.reduce(rows, function (prev, val, index) {
            prev.push(val);
            var cc = t.treegrid("getChildren", val[opts.idField]);
            if (cc && cc.length) { $.array.merge(prev, cc); }
            return prev;
        }, []) : rows;
    };

    var _originalMethod = {};
    $.extend(_originalMethod, {
        find: $.fn.treegrid.methods.find
    });
    var findRow = function (target, param, grid) {
        var t = grid || $(target);
        if (!$.isFunction(param)) { return _originalMethod.find.call(target, t, param); }
        var rows = getRows(target, true);
        return $.array.first(rows, param);
    };

    var getNode = function (target, id) {
        return $(target).treegrid("find", id);
    };

    var findRows = function (target, param) {
        var t = $(target), ret;
        if ($.isFunction(param)) {
            ret = $.array.filter(getRows(target, true), param);
        } else if ($.array.likeArray(param) && !$.util.isString(param)) {
            ret = $.array.map(param, function (val) { return findRow(target, val, t); });
            ret = $.array.filter(ret, function (val) { return val != undefined && val != null; });
        } else {
            ret = [findRow(target, param, t)];
        }
        return ret;
    };

    var getRowDom = function (target, param) {
        param = $.isPlainObject(param) ? param : { id: param, cascade: false };
        var id = param.id, cascade = param.cascade ? true : false,
            t = $(target), opts = t.treegrid("options"), panel = t.treegrid("getPanel"),
            dom = panel.find(".datagrid-view .datagrid-body tr.datagrid-row[node-id=" + id + "]");
        if (cascade) {
            var children = t.treegrid("getChildren", id);
            $.each(children, function (i, n) { var d = getRowDom(target, n[opts.idField]); dom = dom.add(d); });
        }
        return dom;
    };

    var getNextRow = function (target, id) {
        var t = $(target);
        var row = t.treegrid("getRowDom", id).nextAll("tr.datagrid-row:first"), rowId = row.attr("node-id");
        if (!row.length || !rowId) { return null; }
        return t.treegrid("find", rowId);
    };

    var getPrevRow = function (target, id) {
        var t = $(target);
        var row = t.treegrid("getRowDom", id).prevAll("tr.datagrid-row:first"), rowId = row.attr("node-id");
        if (!row.length || !rowId) { return null; }
        return t.treegrid("find", rowId);
    };

    var isRootNode = function (target, id) {
        var t = $(target), roots = t.treegrid("getRoots"), node = t.treegrid("find", id);
        return node && $.array.contains(roots, node);
    };

    var getNears = function (target, id) {
        var t = $(target), opts = t.treegrid("options");
        if (isRootNode(target, id)) { return t.treegrid("getRoots"); }
        var p = t.treegrid("getParent", id);
        if (!p) { return t.treegrid("getRoots"); }
        return getNearChildren(target, p[opts.idField]);
    };

    var getNearChildren = function (target, id) {
        var t = $(target), opts = t.treegrid("options"),
            children = t.treegrid("getChildren", id);
        return $.array.filter(children, function (val) { return t.treegrid("getParent", val[opts.idField])[opts.idField] == id; });
    };

    var defaults = {

    };

    var methods = {

        //  扩展 easyui-treegrid 的自定义方法；获取 easyui-treegrid 中当前页的行数据(包括根节点和子节点)所构成的一个集合；该方法的参数 cascade 定义为如下类型：
        //      Boolean 类型，默认为 false，表示是否连同子级节点数据一并返回；
        //  返回值：返回一个 Array 数组对象，数组中的每一个元素都表示一个 node；
        //      如果 cascade 为 true，则返回所有根节点以及子节点合并所构成的一个数组；
        //      如果 cascade 为 false，则仅返回所有根节点数据，同 getRoots 方法；
        //      如果 easyui-treegrid 的当前页没有数据，则返回一个长度为 0 的数组。
        getRows: function (jq, cascade) { return getRows(jq[0], cascade); },

        //  重写 easyui-treegrid 的原生方法 find，使之功能更加丰富。
        //  获取当前 easyui-treegrid 当前页指定 idField(主键) 的节点对象并返回；该方法的参数 param 可以定义为如下两种类型：
        //      待查找的行数据的 idField(主键) 字段值；
        //      function 类型，该回调函数签名为 function(row, index, rows)，其中 row 表示行数据对象、index 表示行索引号、rows 表示当前 easyui-treegrid 所有节点对象集合；
        //          如果 param 参数为 function 类型，则 findRow 方法会对当前 easyui-treegrid 的当前页的每一行数据调用该回调函数；
        //          当回调函数返回 true 时，则表示找到需要查找的结果，立即停止循环调用并返回该行数据；
        //          如果回调函数始终未返回 true，则该回调函数会一直遍历 rows 直到最后并返回 null。
        //  返回值：返回一个 JSON-Object，表示一个行节点数据对象；如果未找到相应数据，则返回 null。
        find: function (jq, param) { return findRow(jq[0], param); },

        //  扩展 easyui-treegrid 的自定义方法；获取当前 easyui-treegrid 中当前页指定 idField(主键) 的节点数据对象；同 find 方法。
        getNode: function (jq, id) { return getNode(jq[0], id); },

        //  扩展 easyui-treegrid 的自定义方法；获取当前 easyui-treegrid 中当前页指定 idField(主键) 的节点数据对象；同 find 方法。
        findRow: function (jq, param) { return findRow(jq[0], param); },

        //  扩展 easyui-treegrid 的自定义方法；获取当前 easyui-treegrid 当前页上的指定行数据集合并返回；该方法的参数 param 可以定义为如下两种类型：
        //      Function 类型，该回调函数签名为 function(row, index, rows)，其中 row 表示行数据对象、index 表示行索引号、rows 表示当前 easyui-treegrid 所有节点对象集合；
        //          如果 param 参数为 Function 类型，则 findRows 方法会对当前 easyui-treegrid 的当前页的每一行数据调用该回调函数；
        //          当回调函数返回 true 时，则返回的结果集中将会包含该行数据；
        //          如果该回调函数始终未返回 true，则该方法最终返回一个长度为 0 的数组对象。
        //      Array 类型，数组中的每一项都可以定义为如下类型：
        //          待查找的行数据的 idField(主键) 字段值；
        //          Function 类型；具体回调函数签名参考 findRow 方法中 param 参数为 function 类型时的定义；
        //          当 param 参数定义为 Array 类型时，则 findRows 方法会对数组中的每一项循环调用 findRow 方法，并过滤掉 findRow 方法返回 null 的结果行；
        //  返回值：返回一个 Array 数组对象；数组中的每一项都是 JSON-Object 类型，表示一个行数据对象；如果未找到相应数据，则返回一个长度为 0 的数组对象。
        findRows: function (jq, param) { return findRows(jq[0], param); },

        //  扩展 easyui-treegrid 的自定义方法；获取当前 easyui-treegrid 当前页上的多个节点所构成的一个数据集合；同 findRows 方法。
        getNodes: function (jq, param) { return findRows(jq[0], param); },

        //  扩展 easyui-treegrid 的自定义方法；获取 easyui-treegrid 中当前页指定行节点的 DOM-jQuery 对象元素集合；该方法的参数 param 可以定义为以下两种类型：
        //      1、表示要获取的行节点的 idField(主键) 值；
        //      2、JSON-Object 对象，该对象需定义如下属性：
        //          id:     表示要获取的行节点的 idField(主键) 值；
        //          cascade:Boolean 类型值，默认为 false，表示是否连同其子级节点的 DOM 行对象一并获取并返回。
        //  返回值：如果当前页存在 idField(主键) 指示的行，则返回该行的 DOM-jQuery 对象集合，该集合中包含的 DOM 节点级别为一组 tr class="datagrid-row" 对象；
        //          否则返回一个空的 jQuery 对象。
        getRowDom: function (jq, param) { return getRowDom(jq[0], param); },

        //  扩展 easyui-treegrid 的自定义方法；获取指定节点的平级下一格位置的 tree-node 节点；该方法定义如下参数：
        //      id:  指定的表示 tree-node 对象的 idField 值；
        //  返回值：返回 tree-node idField 的同级别下一格位置的 tree-node 节点 node 对象；
        //      如果该 tree-node idField 为当前级别的最后一个节点即没有下一格节点；则返回 null。
        nextRow: function (jq, id) { return getNextRow(jq[0], id); },

        //  扩展 easyui-treegrid 的自定义方法；获取指定节点的平级上一格位置的 tree-node 节点；该方法定义如下参数：
        //      id:  指定的表示 tree-node 对象的 idField 值；
        //  返回值：返回 tree-node idField 的同级别上一格位置的 tree-node 节点对象；该 tree-node 对象含有如下属性：
        //      如果该 tree-node idField 为当前级别的第一个节点即没有上一格节点；则返回 null。
        prevRow: function (jq, id) { return getPrevRow(jq[0], id); },

        //  扩展 easyui-treegrid 的自定义方法；获取指定节点的同级所有节点(包含自身)；该方法定义如下参数：
        //      id:  指定的表示 tree-node 对象的 idField 值；
        //  返回值：返回 tree-node idField 的同级别(具有和当前 tree-node idField 同一个父级节点)所有节点构成的一个数组对象；
        //      如果传入的参数 id 是某个根节点的 idField 或者未定义 idField 参数，则该方法和 getRoots 方法返回的值相同；
        getNears: function (jq, id) { return getNears(jq[0], id); },

        //  扩展 easyui-treegrid 的自定义方法；获取指定节点的下一级所有节点；该方法定义如下参数：
        //      id:  指定的表示 tree-node 对象的 idField 值；
        //  返回值：返回 tree-node id 的下一级所有节点构成的一个数组对象；
        //      如果传入的参数 id 没有子节点，则返回一个包含 0 个元素的数组。
        //  备注：该方法和 getChildren 的不同之处在于，getChildren 方法返回的是 tree-node id 下的所有子节点内容；
        getNearChildren: function (jq, id) { return getNearChildren(jq[0], id); }
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.getColumnInfo.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-11
*
* 依赖项：
*   1、jquery.jdirk.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var getColumnData = function (target, param) {
        param = $.isPlainObject(param) ? param : { field: param, cascade: false };
        var field = param.field, cascade = param.cascade,
            t = $(target), rows = t.treegrid("getRows", cascade);
        return $.array.map(rows, function (val) { return val[field]; });
    };

    var defaults = {

    };

    var methods = {

        //  扩展 easyui-treegrid 的自定义方法；获取 easyui-treegrid 中当前页指定列所有行的单元格数据所构成的一个数组；该方法的参数 param 可以定义为如下两种类型：
        //      1、表示要获取的列的 field 值；
        //      2、JSON-Object 类型，包含如下属性：
        //          field: 要获取的数据的列的 field 名；
        //          cascade：Boolean 类型，默认为 false； 表示返回的结果集中是否还包括子节点数据；
        //  返回值：返回一个数组，数组中每一个元素都是其数据行的该列的值，数组的长度等于 grid.treegrid("getRows", cascade) 的长度；
        //          如果传入的列名不存在，则返回数组的长度同样等于 grid.treegrid("getRows") 的长度，只是每个元素的值都为 undefined.
        getColumnData: function (jq, param) { return getColumnData(jq[0], param); },
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.rowState.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-11
*
* 依赖项：
*   1、jquery.jdirk.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var isChecked = function (target, id) {
        var t = $(target), opts = t.treegrid("options"), rows = t.treegrid("getChecked");
        return $.array.contains(rows, id, function (val) { return val[opts.idField] == id; });
    };

    var isSelected = function (target, id) {
        var t = $(target), opts = t.treegrid("options"), rows = t.treegrid("getSelections");
        return $.array.contains(rows, id, function (val) { return val[opts.idField] == id; });
    };

    var isEditing = function (target, id) {
        var t = $(target), panel = t.treegrid("getPanel");
        return panel.find("div.datagrid-view div.datagrid-body table tr.datagrid-row[node-id=" + id + "]").hasClass("datagrid-row-editing");
    };

    var defaults = {

    };

    var methods = {

        //  扩展 easyui-treegrid 的自定义方法；判断指定的 tree-node 是否被 check；该方法的参数 id 表示要判断的节点的 idField 值；
        //  返回值：如果参数 id 所表示的 tree-node 被 check，则返回 true，否则返回 false。
        isChecked: function (jq, id) { return isChecked(jq[0], id); },

        //  扩展 easyui-treegrid 的自定义方法；判断指定的 tree-node 是否被 select；该方法的参数 id 表示要判断的节点的 idField 值；
        //  返回值：如果参数 id 所表示的 tree-node 被 select，则返回 true，否则返回 false。
        isSelected: function (jq, id) { return isSelected(jq[0], id); },

        //  扩展 easyui-treegrid 的自定义方法；判断指定的 tree-node 是否开启行编辑状态；该方法的参数 id 表示要判断的节点的 idField 值；
        //  返回值：如果参数 id 所表示的 tree-node 正开启行编辑状态，则返回 true，否则返回 false。
        isEditing: function (jq, id) { return isEditing(jq[0], id); }
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.getCellInfo.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-11
*
* 依赖项：
*   1、jquery.jdirk.js
*   1、jeasyui.extensions.treegrid.getRowInfo.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var getCellData = function (target, pos) {
        if (!pos || !pos.field || pos.id == null || pos.id == undefined) { return undefined; }
        var t = $(target), row = t.treegrid("find", pos.id);
        return row[pos.field];
    };

    var getCellDom = function (target, pos) {
        if (!pos || !pos.field || pos.id == null || pos.id == undefined) { return $(); }
        var t = $(target), tr = t.treegrid("getRowDom", pos.id);
        return tr.find("td[field=" + pos.field + "] .datagrid-cell");
    };

    var getCellDisplay = function (target, pos) {
        var cell = getCellDom(target, pos);
        return cell && cell.length ? cell.text() : undefined;
    };

    var defaults = {

    };

    var methods = {

        //  扩展 easyui-treegrid 的自定义方法；获取 easyui-treegrid 中当前页指定单元格的数据；该方法的参数 pos 为一个 JSON-Object 对象，包含如下属性：
        //      field:  表示要获取的单元格位于哪个列；
        //      id:     表示要获取的单元格位于哪个行的节点 id；
        //  返回值：如果当前页存在指定列的指定行，则返回该列中指定行及指定列的单元格数据；否则返回 undefined。
        getCellData: function (jq, pos) { return getCellData(jq[0], pos); },

        //  扩展 easyui-treegrid 的自定义方法；获取 easyui-treegrid 中当前页指定单元格的 Dom-jQuery 对象元素；该方法的参数 pos 为一个 JSON-Object 对象，包含如下属性：
        //      field:  表示要获取的单元格位于哪个列；
        //      id:     表示要获取的单元格位于哪个行的节点 id；
        //  返回值：如果当前页存在指定列的指定行，则返回该列中指定行的 DOM-jQuery 对象，该对象中包含的 DOM 节点级别为一个 div class="datagrid-cell" 对象；
        //          否则返回一个空的 jQuery 对象。
        getCellDom: function (jq, pos) { return getCellDom(jq[0], pos); },

        //  扩展 easyui-treegrid 的自定义方法；获取 easyui-treegrid 中当前页指定单元格的显示数据(经过 formatter 格式化后的显示数据)；
        //  该方法的参数 pos 为一个 JSON-Object 对象，包含如下属性：
        //      field:  表示要获取的单元格位于哪个列；
        //      id:     表示要获取的单元格位于哪个行的节点 id；
        //  返回值：如果当前页存在指定列的指定行，则返回该列中指定行的单元格的显示数据(经过 formatter 格式化后的显示数据)；否则返回 undefined。
        getCellDisplay: function (jq, pos) { return getCellDisplay(jq[0], pos); },
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.selectCheck.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-11
*
* 依赖项：
*   1、jquery.jdirk.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var _originalMethod = {};
    $.extend(_originalMethod, {
        select: $.fn.treegrid.methods.select,
        unselect: $.fn.treegrid.methods.unselect
    });
    var selectRow = function (target, param) {
        param = $.isPlainObject(param) ? param : { id: param, cascade: false };
        var id = param.id, cascade = param.cascade ? true : false, t = $(target);
        _originalMethod.select.call(t, t, id);
        if (cascade) {
            var opts = t.treegrid("options");
            $.each(t.treegrid("getChildren", id), function () { _originalMethod.select.call(t, t, this[opts.idField]); });
        }
    };

    var unselectRow = function (target, param) {
        param = $.isPlainObject(param) ? param : { id: param, cascade: false };
        var id = param.id, cascade = param.cascade ? true : false, t = $(target);
        _originalMethod.unselect.call(t, t, id);
        if (cascade) {
            var opts = t.treegrid("options");
            $.each(t.treegrid("getChildren", id), function () { _originalMethod.unselect.call(t, t, this[opts.idField]); });
        }
    };

    var checkRow = function (target, param) {
        param = $.isPlainObject(param) ? param : { id: param, cascade: false };
        var id = param.id, cascade = param.cascade ? true : false, t = $(target);
        t.datagrid("checkRow", id);
        if (cascade) {
            var opts = t.treegrid("options");
            $.each(t.treegrid("getChildren", id), function () { t.datagrid("checkRow", this[opts.idField]); });
        }
    };

    var uncheckRow = function (target, param) {
        param = $.isPlainObject(param) ? param : { id: param, cascade: false };
        var id = param.id, cascade = param.cascade ? true : false, t = $(target);
        t.datagrid("uncheckRow", id);
        if (cascade) {
            var opts = t.treegrid("options");
            $.each(t.treegrid("getChildren", id), function () { t.datagrid("uncheckRow", this[opts.idField]); });
        }
    };


    var defaults = {

    };

    var methods = {

        //  重写 easyui-treegrid 的源生方法 select，使之功能更加丰富；
        //  选择 easyui-treegrid 当前页的某行节点数据；该方法的参数 param 可以定义为如下两种类型：
        //      1、表示行节点的 idField(主键) 值；
        //      2、JSON-Object 对象，该对象需定义如下属性：
        //          id:     表示要选择的行节点的 idField(主键) 值；
        //          cascade:Boolean 类型值，默认为 false，表示是否连同其子级节点一并选择。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        select: function (jq, param) { return jq.each(function () { selectRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法，选择 easyui-treegrid 当前页的某行节点数据；
        //  同 select 方法；
        selectRow: function (jq, param) { return jq.each(function () { selectRow(this, param); }); },

        //  重写 easyui-treegrid 的源生方法 unselect，使之功能更加丰富；
        //  不选择 easyui-treegrid 当前页的某行节点数据；该方法的参数 param 可以定义为如下两种类型：
        //      1、表示行节点的 idField(主键) 值；
        //      2、JSON-Object 对象，该对象需定义如下属性：
        //          id:     表示要选择的行节点的 idField(主键) 值；
        //          cascade:Boolean 类型值，默认为 false，表示是否连同其子级节点一并不选择。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        unselect: function (jq, param) { return jq.each(function () { unselectRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；不选择 easyui-treegrid 当前页的某行节点数据；
        //  同 unselect 方法；
        unselectRow: function (jq, param) { return jq.each(function () { unselectRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；选中 easyui-treegrid 当前页的某行节点数据；该方法的参数 param 可以定义为如下两种类型：
        //      1、表示行节点的 idField(主键) 值；
        //      2、JSON-Object 对象，该对象需定义如下属性：
        //          id:     表示要选中的行节点的 idField(主键) 值；
        //          cascade:Boolean 类型值，默认为 false，表示是否连同其子级节点一并选中。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        check: function (jq, param) { return jq.each(function () { checkRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；选中 easyui-treegrid 当前页的某行节点数据；
        //  同 check 方法。
        checkRow: function (jq, param) { return jq.each(function () { checkRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；不选中 easyui-treegrid 当前页的某行节点数据；该方法的参数 param 可以定义为如下两种类型：
        //      1、表示行节点的 idField(主键) 值；
        //      2、JSON-Object 对象，该对象需定义如下属性：
        //          id:     表示要选中的行节点的 idField(主键) 值；
        //          cascade:Boolean 类型值，默认为 false，表示是否连同其子级节点一并不选中。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        uncheck: function (jq, param) { return jq.each(function () { uncheckRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；不选中 easyui-treegrid 当前页的某行节点数据；
        //  同 uncheck 方法。
        uncheckRow: function (jq, param) { return jq.each(function () { uncheckRow(this, param); }); }
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.checkPosition.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-15
*
* 依赖项：
*   1、jquery.jdirk.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var isRootNode = function (target, id) {
        var t = $(target), roots = t.treegrid("getRoots"), node = t.treegrid("find", id);
        return node && $.array.contains(roots, node);
    };

    var isParent = function (target, param) {
        var t = $(target), node = t.treegrid("find", param.id2);
        var children = t.treegrid("getChildren", param.id1);
        return $.array.contains(children, node);
    };

    var isChild = function (target, param) {
        var t = $(target), node = t.treegrid("find", param.id1);
        var children = t.treegrid("getChildren", param.id2);
        return $.array.contains(children, node);
    };

    var isSibling = function (target, param) {
        var t = $(target), p1 = t.treegrid("getParent", param.id1), p2 = t.treegrid("getParent", param.id2);
        return p1 && p2 && p1 == p2;
    };

    var defaults = {

    };

    var methods = {

        //  扩展 easyui-treegrid 的自定义方法；判断指定的 tree-node 是否为根节点；该方法定义如下参数：
        //      id: 用于判断的 tree-node 对象的 idField 值。
        //  返回值：如果指定的 jQuery 对象是该 easyui-treegrid 的根节点，则返回 true，否则返回 false。
        isRoot: function (jq, id) { return isRootNode(jq[0], id); },

        //  扩展 easyui-treegrid 的自定义方法；判断一个节点是否为另一个节点的父节点；该方法定义如下参数：
        //      param：  这是一个 JSON-Object，该对象定义如下属性：
        //          id1:    用于判断的第一个 tree-node 对象的 idField 值；
        //          id2:    用于判断的第二个 tree-node 对象的 idField 值；
        //  返回值：如果 tree-node id1 是 tree-node id2 的父节点，则返回 true，否则返回 false。
        isParent: function (jq, param) { return isParent(jq[0], param); },

        //  扩展 easyui-treegrid 的自定义方法；判断一个节点是否为另一个节点的子节点；该方法定义如下参数：
        //      param：  这是一个 JSON-Object，该对象定义如下属性：
        //          id1:    用于判断的第一个 tree-node 对象的 idField 值；
        //          id2:    用于判断的第二个 tree-node 对象的 idField 值；
        //  返回值：如果 tree-node id1 是 tree-node id2 的子节点，则返回 true，否则返回 false。
        isChild: function (jq, param) { return isChild(jq[0], param); },

        //  扩展 easyui-treegrid 的自定义方法；判断一个节点是否和另一个节点为具有同一个父节点的平级节点；该方法定义如下参数：
        //      param：  这是一个 JSON-Object，该对象定义如下属性：
        //          id1:    用于判断的第一个 tree-node 对象的 idField 值；
        //          id2:    用于判断的第二个 tree-node 对象的 idField 值；
        //  返回值：如果 tree-node id1 和 tree-node id2 是具有同一个父级节点的平级节点，则返回 true，否则返回 false。
        isSibling: function (jq, param) { return isSibling(jq[0], param); },


    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.tooltip.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-22
*
* 依赖项：
*   1、jquery.jdirk.js
*   2、jeasyui.extensions.datagrid.getColumnInfo.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var _originalMethod = {};
    $.extend(_originalMethod, {
        beginEdit: $.fn.treegrid.methods.beginEdit
    });



    function beginEdit(target, id) {
        var t = $(target),
            ret = _originalMethod.beginEdit.call(t, id),
            editing = isEditing(target, id);
        if (!editing) {
            return ret;
        }
        hideRowTooltip(target, id);
        return ret;
    }

    var isEditing = function (target, id) {
        var t = $(target), panel = t.treegrid("getPanel");
        return panel.find("div.datagrid-view div.datagrid-body table tr.datagrid-row[node-id=" + id + "]").hasClass("datagrid-row-editing");
    };

    var getRowDom = function (target, param) {
        param = $.isPlainObject(param) ? param : { id: param, cascade: false };
        var id = param.id, cascade = param.cascade ? true : false,
            t = $(target), opts = t.treegrid("options"), panel = t.treegrid("getPanel"),
            dom = panel.find(".datagrid-view .datagrid-body tr.datagrid-row[node-id=" + id + "]");
        if (cascade) {
            var children = t.treegrid("getChildren", id);
            $.each(children, function (i, n) { var d = getRowDom(target, n[opts.idField]); dom = dom.add(d); });
        }
        return dom;
    };

    var getCellDom = function (target, pos) {
        if (!pos || !pos.field || pos.id == null || pos.id == undefined) { return $(); }
        var t = $(target), tr = getRowDom(target, pos.id);
        return tr.find("td[field=" + pos.field + "] .datagrid-cell");
    };

    var getCellHtml = function (target, pos) {
        var cell = getCellDom(target, pos);
        return cell && cell.length ? cell.text() : undefined;
    };


    function initExtendColumnOptions(t, opts) {
        var target = t[0],
            state = $.data(target, "treegrid"),
            cols = t.treegrid("getColumnOptions", "all");
        $.each(cols, function (i, col) {
            $.union(col, $.fn.treegrid.extensions.columnOptions);
        });
    }

    function initRowMouseEvent(t, opts) {
        var target = t[0];
        t.treegrid("getPanel").panel("body").delegate("tr.datagrid-row", {
            "mouseenter.datagrid-extensions": function (e) {
                var tr = $(this);
                if (tr.is(".datagrid-row-editing")) { return; }

                var id = tr.attr("node-id"), row = t.treegrid("find", id);
                showRowTooltip(target, id, t, opts, row, tr, e);
            },
            "mouseleave.datagrid-extensions": function () {
                var tr = $(this), id = tr.attr("node-id");
                hideRowTooltip(target, id, tr);
            }
        });
    }

    function showRowTooltip(target, id, t, opts, row, tr, e) {
        t = t || $(target);
        opts = opts || $.data(target, "treegrid").options;
        row = row || t.treegrid("find", id);
        tr = tr || getRowDom(target, id);
        if (opts.rowTooltip) {
            var content = $.isFunction(opts.rowTooltip) ? opts.rowTooltip.call(target, id, row) : getRowTooltipContent(target, id, row);
            tr.each(function () {
                if (!$.data(this, "tooltip")) {
                    $(this).tooltip({
                        content: content,
                        trackMouse: true,
                        showDelay: opts.tooltipDelay
                    }).tooltip("show");
                }
            });
        } else {
            tr.children("td[field]").each(function () {
                var td = $(this),
                    field = td.attr("field"),
                    copts = t.datagrid("getColumnOption", field);
                if (!copts || !copts.tooltip) { return; }
                if (!$.data(td[0], "tooltip")) {
                    var content = $.isFunction(copts.tooltip) ? copts.tooltip.call(target, row[field], row) : getCellHtml(target, { field: field, id: id });
                    td.tooltip({
                        content: content,
                        trackMouse: true,
                        showDelay: opts.tooltipDelay
                    });
                }
                if (e && e.target) {
                    if (td[0] == e.target || $.contains(t[0], e.target)) {
                        td.tooltip("show");
                    }
                } else {
                    td.tooltip("show");
                }
            });
        }
    }

    function hideRowTooltip(target, id, tr) {
        tr = tr || getRowDom(target, id);
        tr.tooltip("destroy").children("td[field]").each(function () {
            $(this).tooltip("destroy");
        });
    }

    function getRowTooltipContent(target, id, row) {
        var t = $(target), cols = t.datagrid("getColumnOptions", "all"),
            content = $("<table style='padding: 5px;'></table>");
        $.each(cols, function (i, copts) {
            if (!copts || !copts.field || !copts.title) { return; }
            var text = getCellHtml(target, { field: copts.field, id: id });
            content.append("<tr style='height: 20px;'><td style='text-align: right; width: 150px;'>" + copts.title + ":</td><td style='width: 250px;'>" + text + "</td></tr>");
        });
        return content;
    }



    function initializeExtensions(target) {
        var t = $(target),
            state = $.data(target, "treegrid"),
            opts = state.options;
        initExtendColumnOptions(t, opts);
        initRowMouseEvent(t, opts);
    }

    var _treegrid = $.fn.treegrid;
    $.fn.treegrid = function (options, param) {
        if (typeof options == "string") {
            return _treegrid.apply(this, arguments);
        }
        options = options || {};
        return this.each(function () {
            var jq = $(this),
                isInited = $.data(this, "treegrid") ? true : false,
                opts = isInited ? options : $.extend({},
                        $.fn.treegrid.parseOptions(this),
                        $.parser.parseOptions(this, [
                            {
                                tooltipDelay: "number"
                            },
                            {
                                rowTooltip: "boolean"
                            }
                        ]), options);
            _treegrid.call(jq, opts, param);
            if (!isInited) {
                initializeExtensions(this);
            }
        });
    };
    $.union($.fn.treegrid, _treegrid);



    //  增加了 easyui-treegrid 中列 columnOption 的部分自定义扩展属性
    var columnOptions = {

        // 表示是否启用该列的 tooptip 效果，其值可以是以下两种类型：
        //      Boolean 类型，表示是否启用该列的 tooltip；
        //      Function 类型，其函数签名为 function (value, rowData)，表示为该列启用 tooltip 的方式；
        //          该回调函数返回一个 String 类型值，表示 tooltip 的 content 内容。
        // 默认为 Boolean 类型，值为 false。
        tooltip: false
    };

    var defaults = {

        //  扩展 easyui-treegrid 的自定义属性，该属性表示是否启用行数据的 tooltip 功能；
        //  该属性可以是一个 Boolean 类型值；也可以是一个签名为 function(nodeId, rowData) 的回调函数；
        //  如果该参数是一个回调函数，则表示启用行数据的 tooltip 功能，并且该函数的返回值为 tooltip 的 content 值。
        //  默认为 Boolean 类型，值为 false。
        //  注意：当启用该配置属性后，所有列的 tooltip 属性就会自动失效。
        rowTooltip: false,

        // 扩展 easyui-treegrid 的自定义属性，该属性表示 rowTooltip 为 true 或 列的扩展属性 tooltip 为 true 时，显示 tooltip 时的延迟毫秒数；
        // 该属性的值是 Number 类型，默认为 300 。
        tooltipDelay: 300
    };

    var methods = {

        //  重写 easyui-treegrid 的原生方法 beginEdit ，以支持自定义属性 rowTooltip 和列属性 tooltip 的扩展功能；
        beginEdit: function (jq, id) { return jq.each(function () { beginEdit(this, id); }); }
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.columnOptions) {
        $.extend(compent.extensions.columnOptions, columnOptions);
    }
    else {
        compent.extensions.columnOptions = columnOptions;
    }

    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.liveSearch.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-11
*
* 依赖项：
*   1、jquery.jdirk.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var liveSearch = function (target, param) {
        var t = $(target), panel = t.treegrid("getPanel"), opts = t.treegrid("options"), treeField = opts.treeField,
            cells, field, value = param, regular = false, ignoreCase = true, regexp;
        if ($.isPlainObject(param)) {
            value = param.value;
            field = param.field;
            regular = param.regular;
            ignoreCase = param.ignoreCase;
            cells = panel.find("div.datagrid-body tr.datagrid-row td[" + (field ? "field=" + field : "field") + "] div.datagrid-cell");
        } else {
            cells = panel.find("div.datagrid-body tr.datagrid-row td[field] div.datagrid-cell");
        }
        regexp = regular ? new RegExp(value, ignoreCase ? "gm" : "igm") : value;
        cells.each(function () {
            var cell = $(this), td = cell.parent(), field = td.attr("field");
            if (field == treeField) { cell = cell.find("span.tree-title"); }
            cell.find("span.datagrid-cell-hightlight").replaceWith(function () { return $(this).text(); });
            if (!value) { return; }
            var text = cell.html(); if (!text) { return; }
            cell.html($.string.replaceAll(text, value, "<span class='datagrid-cell-hightlight'>" + value + "</span>"));
        });
    };

    var clearLiveHighLight = function (target, field) {
        var t = $(target), panel = t.treegrid("getPanel"), opts = t.treegrid("options"), treeField = opts.treeField, cells;
        if (field == null || field == undefined) {
            cells = panel.find("div.datagrid-body tr.datagrid-row td[field] div.datagrid-cell");
        }
        else {
            cells = panel.find("div.datagrid-body tr.datagrid-row td[field=" + String(field) + "] div.datagrid-cell");
        }

        cells.each(function () {
            var cell = $(this), td = cell.parent(), field = td.attr("field");
            if (field == treeField) { cell = cell.find("span.tree-title"); }
            cell.find("span.datagrid-cell-hightlight").replaceWith(function () { return $(this).text(); });
        });
    };

    var defaults = {

    };

    var methods = {

        //  扩展 easyui-treegrid 的自定义方法；对当前 easyui-treegrid 中进行高亮关键词查询；该方法的 param 可以定义为如下两种类型：
        //      1、String 类型值：表示要对所有列进行的高亮查询关键词；
        //      2、JSON-Object：表示对特定列进行高亮查询的参数，该对象类型参数包含如下属性：
        //          field:      表示要进行高亮查询的列；
        //          value:      表示要进行高亮查询的关键词；
        //          regular:    Boolean 类型值，默认为 false；指示该关键词是否为正则表达式；
        //          ignoreCase: Boolean 类型值，默认为 true；指示高亮查询时是否忽略大小写。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        liveSearch: function (jq, param) { return jq.each(function () { liveSearch(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；清除当前 easyui-treegrid 中进行高亮关键词查询后产生的高亮效果；该方法的 field 可以定义为如下类型：
        //      1、String 类型值：表示要对特定列的高亮效果进行清除，不提供该参数则表示要清除所有列的高亮效果；
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        clearLiveHighLight: function (jq, field) { return jq.each(function () { clearLiveHighLight(this, field); }); }
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.cascadeCheck.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-22
*
* 依赖项：
*   1、jquery.jdirk.js
*   2、jeasyui.extensions.treegrid.rowState.js
*   3、jeasyui.extensions.treegrid.selectCheck.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");


    function resetExtensionsEvent(t, opts) {
        var target = t[0];
        if (opts.cascadeCheck) {
            //重写 easyui-treegrid 的 onCheck、onUncheck 属性，以支持扩展功能。
            var _onCheck = opts.onCheck;
            opts.onCheck = function (row) {
                if ($.isFunction(_onCheck)) { _onCheck.apply(this, arguments); }
                if (opts.checkOnSelect && opts.singleSelect) { return; }
                var idField = opts.idField, id = row[idField], children, checked, parent = t.treegrid("getParent", id);
                while (parent) {
                    children = t.treegrid("getChildren", parent[idField]);
                    checked = t.treegrid("getChecked");
                    if (!$.array.some(children, function (val) { return !$.array.contains(checked, val); })) {
                        if (!t.treegrid("isChecked", parent[idField])) { t.treegrid("check", parent[idField]); }
                    }
                    parent = t.treegrid("getParent", parent[idField]);
                }
                $.each(t.treegrid("getChildren", id), function (i, n) {
                    if (!t.treegrid("isChecked", n[idField])) { t.treegrid("check", n[idField]); }
                });

            };
            var _onUncheck = opts.onUncheck;
            opts.onUncheck = function (row) {
                if ($.isFunction(_onUncheck)) { _onUncheck.apply(this, arguments); }
                if (opts.checkOnSelect && opts.singleSelect) { return; }
                var idField = opts.idField, id = row[idField], children, checked, parent = t.treegrid("getParent", id);
                while (parent) {
                    children = t.treegrid("getChildren", parent[idField]);
                    checked = t.treegrid("getChecked");
                    if (!$.array.some(children, function (val) { return $.array.contains(checked, val); })) {
                        if (t.treegrid("isChecked", parent[idField])) { t.treegrid("uncheck", parent[idField]); }
                    }
                    parent = t.treegrid("getParent", parent[idField]);
                }
                $.each(t.treegrid("getChildren", id), function (i, n) {
                    t.treegrid("uncheck", n[idField]);
                });
            };
        }
    }

    function initializeExtensions(target) {
        var t = $(target),
            state = $.data(target, "treegrid"),
            opts = state.options;
    }

    function initializeExtensionsBefore(target, opts) {
        var t = $(target);

        resetExtensionsEvent(t, opts);
    }

    var _treegrid = $.fn.treegrid;
    $.fn.treegrid = function (options, param) {
        if (typeof options == "string") {
            return _treegrid.apply(this, arguments);
        }
        options = options || {};
        return this.each(function () {
            var jq = $(this),
                isInited = $.data(this, "treegrid") ? true : false,
                opts = isInited ? options : $.extend({},
                        $.fn.treegrid.parseOptions(this),
                        $.parser.parseOptions(this, [
                            { cascadeCheck: "boolean" }
                        ]), options);
            if (!isInited) {
                //由于部分事件（如onClickRow）的重写必须在初始化之前才有效，因此需提前处理
                initializeExtensionsBefore(this, opts);
            }
            _treegrid.call(jq, opts, param);
            if (!isInited) {
                initializeExtensions(this);
            }
        });
    };
    $.union($.fn.treegrid, _treegrid);

    var defaults = {

        //  扩展 easyui-treegrid 的自定义属性，表示当前 easyui-treegrid 控件是否支持级联选择；
        //  Boolean 类型值，默认为 false。
        //  备注：在当 checkOnSelect、singleSelect 这两个属性都为 true 的情况下，不支持级联选择，此时属性 cascadeCheck 无效；
        cascadeCheck: false
    };

    var methods = {


    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.operateColumn.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-21
*
* 依赖项：
*   1、jquery.jdirk.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");


    var defaults = {

    };

    var methods = {

        //  扩展 easyui-treegrid 的自定义方法；用于取消指定树节点的选择状态；该方法定义如下参数：
        //      target:  指定的表示 tree-node 的 jQuery 或 DOM 对象。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 对象。
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.operateRow.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-11
*
* 依赖项：
*   1、jquery.jdirk.js
*   2、jeasyui.extensions.treegrid.getRowInfo.js
*   3、jeasyui.extensions.treegrid.selectCheck.js
*   4、jeasyui.extensions.treegrid.checkPostion.js
*   5、jeasyui.extensions.treegrid.getCellInfo.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    var _originalMethod = {};
    $.extend(_originalMethod, {
        remove: $.fn.treegrid.methods.remove,
        append: $.fn.treegrid.methods.append,
        insert: $.fn.treegrid.methods.insert,
        update: $.fn.treegrid.methods.update
    });
    var removeRow = function (target, param) {
        var t = $(target), state = $.data(target, "treegrid"), opts = state.options, row;
        if (!$.isFunction(param)) {
            row = t.treegrid("find", param);
        }
        else {
            var rows = t.treegrid("getRows", true);
            row = $.array.first(rows, param);
        }
        if (row && $.isFunction(opts.onBeforeRemove) && opts.onBeforeRemove.call(target, row) != false) {
            _originalMethod.remove.call(t, t, row[opts.idField]);
            $.array.remove(state.hiddenRows, row, function (item1, item2) { return item1[opts.idField] == item2[opts.item2]; });
            if ($.isFunction(opts.onRemove)) { opts.onRemove.call(target, row); }
        }
    };

    var removeRows = function (target, param) {
        var isArray = $.array.likeArray(param) && !$.util.isString(param);
        if (isArray) { $.each(param, function (index, val) { removeRow(target, val); }); return; }
        if ($.isFunction(param)) {
            var t = $(target), state = $.data(target, "treegrid"), opts = state.options, rows = t.treegrid("getRows", true), data = $.array.filter(rows, param);
            $.each(data, function (index, row) {
                if ($.isFunction(opts.onBeforeRemove) && opts.onBeforeRemove.call(target, row) != false) {
                    _originalMethod.remove.call(t, t, row[opts.idField]);
                    $.array.remove(state.hiddenRows, row, function (item1, item2) { return item1[opts.idField] == item2[opts.item2]; });
                    if ($.isFunction(opts.onRemove)) { opts.onRemove.call(target, row); }
                }
            });
        }
    };

    var hideRow = function (target, param) {
        var t = $(target), state = $.data(target, "treegrid"), opts = state.options;
        var row = t.treegrid("find", param), id = row ? row[opts.idField] : null;
        if (id == null) { return; }

        $.array.unique(state.hiddenRows, row, t.treegrid("getChildren", id));
        t.treegrid("unselectRow", { id: id, cascade: true }).treegrid("uncheckRow", { id: id, cascade: true });
        t.treegrid("getRowDom", { id: id, cascade: true }).addClass("datagrid-row-hidden");
    };

    var showRow = function (target, param) {
        var t = $(target), state = $.data(target, "treegrid"), opts = state.options;
        var row = t.treegrid("find", param), id = row ? row[opts.idField] : null;
        if (id == null) { return; }
        var rows = $.array.merge(t.treegrid("getChildren", id), row);
        $.each(rows, function (index, item) {
            $.array.remove(state.hiddenRows, this);
        });
        t.treegrid("getRowDom", { id: id, cascade: true }).removeClass("datagrid-row-hidden");
    };

    var hideRows = function (target, param) {
        var t = $(target), state = $.data(target, "treegrid"), opts = state.options;
        if (param == true) {
            var rows = t.treegrid("getRows", true);
            $.array.clear(state.hiddenRows);
            $.array.copy(state.hiddenRows, rows);
            t.treegrid("unselectAll").treegrid("uncheckAll");
            $.each(rows, function (i, n) {
                t.treegrid("getRowDom", n[opts.idField]).addClass("datagrid-row-hidden");
            });
        } else {
            var rows = t.treegrid("findRows", param);
            $.each(rows, function (i, row) {
                var id = row ? row[opts.idField] : null; if (id == null) { return; }
                $.array.unique(state.hiddenRows, row, t.treegrid("getChildren", id));
                t.treegrid("unselectRow", { id: id, cascade: true }).treegrid("uncheckRow", { id: id, cascade: true });
                t.treegrid("getRowDom", { id: id, cascade: true }).addClass("datagrid-row-hidden");
            });
        }
    };

    var showRows = function (target, param) {
        var t = $(target), state = $.data(target, "treegrid"), opts = state.options;
        if (param == true) {
            var rows = t.treegrid("getRows", true);
            $.array.clear(state.hiddenRows);
            $.each(rows, function (i, n) {
                t.treegrid("getRowDom", n[opts.idField]).removeClass("datagrid-row-hidden");
            });
        } else {
            var rows = t.treegrid("findRows", param);
            $.each(rows, function (i, row) {
                var id = row ? row[opts.idField] : null; if (id == null) { return; }
                var ps = $.array.merge(t.treegrid("getChildren", id), row);
                $.each(ps, function () { $.array.remove(state.hiddenRows, this); });
                t.treegrid("getRowDom", { id: id, cascade: true }).removeClass("datagrid-row-hidden");
            });
        }
    };

    var getHiddenRows = function (target, cascade) {
        var t = $(target), state = $.data(target, "treegrid");
        if (cascade) { return state.hiddenRows; }
        var roots = t.treegrid("getRoots");
        return $.array.filter(state.hiddenRows, function (val) { return $.array.contains(roots, val); });
    };

    var moveRow = function (target, param) {
        if (!param || !param.source || !param.target || !param.point) { return; }
        if (!$.array.contains(["append", "top", "bottom"], param.point)) { param.point = "append"; }
        var t = $(target),
            sourceNode = t.treegrid("find", param.source), targetNode = t.treegrid("find", param.target);
        if (!sourceNode || !targetNode || sourceNode == targetNode) { return; }

        if (t.treegrid("isParent", { id1: param.source, id2: param.target })) { return; }

        var state = $.data(target, "treegrid"), opts = state.options;
        if ($.isFunction(opts.onBeforeMove) && opts.onBeforeMove.call(target, targetNode, sourceNode, param.point) == false) { return; }

        var node = t.treegrid("pop", param.source);
        switch (param.point) {
            case "append": t.treegrid("append", { parent: param.target, data: [node] }); break;
            case "top": t.treegrid("insert", { before: param.target, data: node }); break;
            case "bottom": t.treegrid("insert", { after: param.target, data: node }); break;
            default: t.treegrid("append", { parent: param.target, data: [node] }); break;
        }
        if (node && $.isFunction(opts.onMove)) { opts.onMove.call(target, targetNode, sourceNode, param.point); }
    };

    var shiftRow = function (target, param) {
        if (!param || !param.id || !param.point || !$.array.contains(["up", "upLevel", "down", "downLevel"], param.point)) { return; }
        var t = $(target), node;
        switch (param.point) {
            case "up": node = t.treegrid("prevRow", param.id); break;
            case "upLevel": node = t.treegrid("getParent", param.id); break;
            case "down": node = t.treegrid("nextRow", param.id); break;
            case "downLevel": node = t.treegrid("prevRow", param.id); break;
            default: break;
        }
        if (!node) { return; }
        var opts = t.treegrid("options");
        t.treegrid("moveRow", { target: node[opts.idField], source: param.id, point: param.point == "up" ? "top" : (param.point == "downLevel" ? "append" : "bottom") });
    };




    function initHeaderFiltersData(t, opts) {
        var target = t[0],
            state = $.data(target, "treegrid");
        state.hiddenRows = [];
    }

    function initializeExtensions(target) {
        var t = $(target),
            state = $.data(target, "treegrid"),
            opts = state.options;

        initHeaderFiltersData(t, opts);
    }

    var _treegrid = $.fn.treegrid;
    $.fn.treegrid = function (options, param) {
        if (typeof options == "string") {
            return _treegrid.apply(this, arguments);
        }
        options = options || {};
        return this.each(function () {
            var jq = $(this),
                isInited = $.data(this, "treegrid") ? true : false,
                opts = isInited ? options : $.extend({},
                        $.fn.treegrid.parseOptions(this), options);
            _treegrid.call(jq, opts, param);
            if (!isInited) {
                initializeExtensions(this);
            }
        });
    };
    $.union($.fn.treegrid, _treegrid);



    var defaults = {

        //  扩展 easyui-treegrid 的自定义事件；该事件表示执行 remove 或 removeRow 方法前所触发的动作；该事件回调函数提供如下两个参数：
        //      row:    表示要进行移除操作的行数据对象；
        //  该事件函数中的 this 指向当前 easyui-treegrid 的 DOM 对象(非 jQuery 对象)；
        //  备注：如果该事件回调函数返回 false，则立即取消即将要执行的移除操作。
        onBeforeRemove: function (row) { },

        //  扩展 easyui-treegrid 的自定义事件；该事件表示执行 remove 或 removeRow 方法后所触发的动作；该事件回调函数提供如下两个参数：
        //      row:    表示要进行移除操作的行数据对象；
        //  该事件函数中的 this 指向当前 easyui-treegrid 的 DOM 对象(非 jQuery 对象)；
        onRemove: function (row) { },

        //  扩展 easyui-treegrid 的自定义事件；该事件表示执行 moveRow 方法前所触发的动作；该事件回调函数提供如下两个参数：
        //      row:    表示要进行移动操作的行数据对象；
        //  该事件函数中的 this 指向当前 easyui-treegrid 的 DOM 对象(非 jQuery 对象)；
        //  备注：如果该事件回调函数返回 false，则立即取消即将要执行的移动操作。
        onBeforeMove: function (targetRow, sourceRow, point) { },

        //  扩展 easyui-treegrid 的自定义事件；该事件表示执行 moveRow 方法后所触发的动作；该事件回调函数提供如下两个参数：
        //      row:    表示要进行移动操作的行数据对象；
        //  该事件函数中的 this 指向当前 easyui-treegrid 的 DOM 对象(非 jQuery 对象)；
        onMove: function (targetRow, sourceRow, point) { }
    };

    var methods = {

        //  重写 easyui-treegrid 的源生方法 remove，使之功能更加丰富；
        //  删除 easyui-treegrid 中当前页指定的节点以及它所有的子节点；参数 param 表示要删除的内容；该参数可以是以下三种类型：
        //      表示要删除的行数据的 idField(主键) 字段值；
        //      Function 类型，该回调函数签名为 function(row, index, rows)，其中 row 表示行数据对象、index 表示行索引号、rows 表示当前 easyui-treegrid 所有节点对象集合；
        //          如果 param 参数为 Function 类型，则 deleteRow 方法会对当前 easyui-treegrid 的当前页的每一行数据调用该回调函数；
        //          当回调函数返回 true 时，则表示查找到了需要被删除的行，deleteRow 方法将会删除该行数据并立即停止和跳出循环操作；
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        remove: function (jq, param) { return jq.each(function () { removeRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；删除 easyui-treegrid 中当前页指定的节点以及它所有的子节点；
        //  同 remove 方法。
        removeRow: function (jq, param) { return jq.each(function () { removeRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；删除多行数据，参数 param 表示要删除的内容；该参数可以是以下两种类型：
        //      Function 类型，该回调函数签名为 function(row, index, rows)，其中 row 表示行数据对象、index 表示行索引号、rows 表示当前 easyui-treegrid 所有节点对象集合；
        //          如果 param 参数为 Function 类型，则 deleteRows 方法会对当前 easyui-treegrid 的当前页的每一行数据调用该回调函数；
        //          当回调函数返回 true 时，则表示查找到了需要被删除的行，deleteRows 方法将会删除该行数据，并遍历下一行数据直至数数据集的末尾；
        //      Array 类型，数组中的每一项目均表示要删除的行的行索引号或者 idField(主键) 字段值。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        removeRows: function (jq, param) { return jq.each(function () { removeRows(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；隐藏当前页数据中指定行的数据；该方法的参数 param 可以是以下两种类型：
        //      待查找的行数据的 idField(主键) 字段值；
        //      function 类型，该回调函数签名为 function(row, index, rows)，其中 row 表示行数据对象、index 表示行索引号、rows 表示当前 easyui-treegrid 所有节点对象集合；
        //          如果 param 参数为 function 类型，则 findRow 方法会对当前 easyui-treegrid 的当前页的每一行数据调用该回调函数；
        //          当回调函数返回 true 时，则表示找到需要查找的结果，立即停止循环调用并隐藏该行数据；
        //          如果回调函数始终未返回 true，则该回调函数会一直遍历 rows 直到最后。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        hideRow: function (jq, param) { return jq.each(function () { hideRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；显示当前页数据中指定行的数据；该方法的参数 param 可以是以下两种类型：
        //      待查找的行数据的 idField(主键) 字段值；
        //      function 类型，该回调函数签名为 function(row, index, rows)，其中 row 表示行数据对象、index 表示行索引号、rows 表示当前 easyui-treegrid 所有节点对象集合；
        //          如果 param 参数为 function 类型，则 findRow 方法会对当前 easyui-treegrid 的当前页的每一行数据调用该回调函数；
        //          当回调函数返回 true 时，则表示找到需要查找的结果，立即停止循环调用并显示该行数据；
        //          如果回调函数始终未返回 true，则该回调函数会一直遍历 rows 直到最后。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        showRow: function (jq, param) { return jq.each(function () { showRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；隐藏当前页数据中指定多行的数据；该方法的参数 param 可以是以下三种类型：
        //      Function 类型，该回调函数签名为 function(row, index, rows)，其中 row 表示行数据对象、index 表示行索引号、rows 表示当前 easyui-treegrid 所有节点对象集合；
        //          如果 param 参数为 Function 类型，则 hideRows 方法会对当前 easyui-treegrid 的当前页的每一行数据调用该回调函数；
        //          当回调函数返回 true 时，则该行数据将会被隐藏；
        //      Array 类型，数组中的每一项都可以定义为如下类型：
        //          待查找的行数据的 idField(主键) 字段值；
        //          Function 类型；具体回调函数签名参考 hideRow 方法中 param 参数为 function 类型时的定义；
        //          当 param 参数定义为 Array 类型时，则 hideRows 方法会对数组中的每一项循环调用 hideRow 方法；
        //      Boolean 类型且为 true：则 hideRows 将会隐藏当前页的所有数据。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        hideRows: function (jq, param) { return jq.each(function () { hideRows(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；显示当前页数据中指定多行的数据；该方法的参数 param 可以是以下三种类型：
        //      Function 类型，该回调函数签名为 function(row, index, rows)，其中 row 表示行数据对象、index 表示行索引号、rows 表示当前 easyui-treegrid 所有节点对象集合；
        //          如果 param 参数为 Function 类型，则 showRows 方法会对当前 easyui-treegrid 的当前页的每一行数据调用该回调函数；
        //          当回调函数返回 true 时，则该行数据将会被显示；
        //      Array 类型，数组中的每一项都可以定义为如下类型：
        //          待查找的行数据的 idField(主键) 字段值；
        //          Function 类型；具体回调函数签名参考 showRow 方法中 param 参数为 function 类型时的定义；
        //          当 param 参数定义为 Array 类型时，则 showRows 方法会对数组中的每一项循环调用 showRow 方法；
        //      Boolean 类型且为 true：则 showRows 将会显示当前页的所有数据。
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 链式对象。
        showRows: function (jq, param) { return jq.each(function () { showRows(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；获取当前页所有隐藏的行数据所构成的一个 Array 对象；该方法的参数 cascade 定义为如下类型：
        //      Boolean 类型，默认为 false，表示是否连同子级节点数据一并返回；
        //  返回值：返回一个 Array 数组对象，数组中的每一个元素都表示一个 node；
        //      如果 cascade 为 true，则返回隐藏的行数据中所有根节点以及子节点合并所构成的一个数组；
        //      如果 cascade 为 false，则仅返回隐藏的行数据中所有根节点数据；
        //      如果 easyui-treegrid 的当前页没有隐藏的行数据，则返回一个长度为 0 的数组。
        getHiddenRows: function (jq, cascade) { return getHiddenRows(jq[0], cascade); },

        //  扩展 easyui-treegrid 的自定义方法；移动指定的节点到另一个位置；该方法定义如下参数：
        //      param:   这是一个 JSON-Object，该对象定义如下属性：
        //          target: 表示目标位置的 tree-node 对象的 idField 值；
        //          source: 表示要移动的 tree-node 对象的 idField 值；
        //          point:  表示移动到目标节点 target 的位置，String 类型，可选的值包括：
        //              "append":   表示追加为目标节点 target 的子节点，默认值；
        //              "top":      表示移动到目标节点 target 的上一格位置；
        //              "bottom":   表示追加为目标节点 target 的下一格位置；
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 对象。
        moveRow: function (jq, param) { return jq.each(function () { moveRow(this, param); }); },

        //  扩展 easyui-treegrid 的自定义方法；移动指定节点的位置；该方法的参数 param 为一个 JSON-Object 类型对象，包含如下属性：
        //      id: 表示要移动的 tree-node 对象的 idField 值；
        //      point:  表示移动 target 的方式，String 类型，可选的值报错：
        //          "up":       表示将 target 所表示的 tree-node 移动到上一格位置；
        //          "upLevel":  表示将 target 所表示的 tree-node 移动到上一级的末尾；
        //          "down":     表示将 target 所表示的 tree-node 移动到下一格位置；
        //          "downLevel":表示将 target 所表示的 tree-node 移动到下一级的末尾；
        //          如果不定义该值或者该值为空或该值不是上面四个之一，则不进行任何操作；
        //  返回值：返回表示当前 easyui-treegrid 组件的 jQuery 对象。
        shiftRow: function (jq, param) { return jq.each(function () { shiftRow(this, param); }); }
    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);
/**
* jQuery EasyUI 1.4.3
* Copyright (c) 2009-2015 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL license: http://www.gnu.org/licenses/gpl.txt
* To use it on other terms please contact us at info@jeasyui.com
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI treegrid 扩展
* jeasyui.extensions.treegrid.other.js
* 开发 流云
* 由 落阳 整理
* 最近更新：2016-03-22
*
* 依赖项：
*   1、jquery.jdirk.js
*
* Copyright (c) 2016 ChenJianwei personal All rights reserved.
*/
(function ($) {

    $.util.namespace("$.fn.treegrid.extensions");

    





    function resetExtensionsEvent(t, opts) {
        var target = t[0];
        if (opts.toggleOnClick) {
            //重写 easyui-treegrid 的 onClickRow 属性，以支持扩展功能。
            var _onClickRow = opts.onClickRow;
            opts.onClickRow = function (row) {
                if ($.isFunction(_onClickRow)) { _onClickRow.apply(this, arguments); }
                t.treegrid("toggle", row[opts.idField]);
            };
        }
    }

    function initializeExtensions(target) {
        var t = $(target),
            state = $.data(target, "treegrid"),
            opts = state.options;
    }

    function initializeExtensionsBefore(target, opts) {
        var t = $(target);

        resetExtensionsEvent(t, opts);
    }

    var _treegrid = $.fn.treegrid;
    $.fn.treegrid = function (options, param) {
        if (typeof options == "string") {
            return _treegrid.apply(this, arguments);
        }
        options = options || {};
        return this.each(function () {
            var jq = $(this),
                isInited = $.data(this, "treegrid") ? true : false,
                opts = isInited ? options : $.extend({},
                        $.fn.treegrid.parseOptions(this),
                        $.parser.parseOptions(this, [
                            { toggleOnClick: "boolean" }
                        ]), options);
            if (!isInited) {
                //由于部分事件（如onClickRow）的重写必须在初始化之前才有效，因此需提前处理
                initializeExtensionsBefore(this, opts);
            }
            _treegrid.call(jq, opts, param);
            if (!isInited) {
                initializeExtensions(this);
            }
        });
    };
    $.union($.fn.treegrid, _treegrid);

    var defaults = {

        //  扩展 easyui-treegrid 的自定义属性，表示当左键点击带有子节点的条目时，是否自动展开/折叠相应节点。
        //  Boolean 类型，默认为 false。
        //  备注：该功能不会影响到 easyui-treegrid 的原生事件 onClick。
        toggleOnClick: false
    };

    var methods = {


    };

    var compent = $.fn.treegrid;
    if (compent.extensions.defaults) {
        $.extend(compent.extensions.defaults, defaults);
    } else {
        compent.extensions.defaults = defaults;
    }

    if (compent.extensions.methods) {
        $.extend(compent.extensions.methods, methods);
    } else {
        compent.extensions.methods = methods;
    }

    $.extend(compent.defaults, defaults);
    $.extend(compent.methods, methods);

})(jQuery);